package collection;

import java.util.*;

public class HashMapStudy {

    public static void main(String[] args) {
        HashMap<String, Integer> nameAge = new HashMap<>(2);
        nameAge.put(null, null);
        nameAge.put("cauchy", 18);
        Set<Map.Entry<String, Integer>> entries = nameAge.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
        // compute computeIfAbsent computeIfPresent 三个计算 key对应的value值
        Integer cauchy = nameAge.compute("cauchy1", (key, value) -> {
            if (value != null) {
                return null;
            } else {
                return 0;
            }
        });
        System.out.println(cauchy);
        System.out.println(nameAge);

        // 测试1.8的扩容，threshold = initialCapacity * defaultLoadFactor = 16 * 0.75 = 12
        // 在1.8 中当 插入第 threshold + 1 个元素时 才会扩容，下面的 testResize 会在插入第13个元素时扩容。
        HashMap<Integer, Integer> testResize = new HashMap<>(16);
        for (int i = 0; i < 16; i++) {
            testResize.put(i, i);
        }

        // 测试1.8的hash冲突，链表node 是头插入还是尾插，因为 hash算法是(h = key.hashCode()) ^ (h >>> 16)。所以取 2^16 和 1 这两个数字
        // 它们调用 HashMap的hash算法结果不相同，但是 它们和 15 的 & 操作结果相同——即找到的数组下标相同。
        // (16^n + 1) 都在 下标为0 的链表里
        HashMap<Integer, Integer> testNodeInsertion = new HashMap<>(16);
        testNodeInsertion.put(1, 1);
        testNodeInsertion.put(1 << 16, 1);
        testNodeInsertion.put(17, 1);
        // 根据 Map的value值倒序
        Queue<HashMap.Entry<Integer, Integer>> entryQueue = new PriorityQueue<>((entry1, entry2) -> entry2.getValue() - entry1.getValue());

    }
}
